﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace StudentManage.Data
{
    public partial class UserList
    {
        public static IQueryable<UserList> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.UserList.Where(queryStr, par);
        }
        public static IQueryable<UserList> All()
        {
            return LinqUtility.LinqContext.UserList;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(UserList), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(UserList), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class RoleUsers
    {
        public static IQueryable<RoleUsers> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.RoleUsers.Where(queryStr, par);
        }
        public static IQueryable<RoleUsers> All()
        {
            return LinqUtility.LinqContext.RoleUsers;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(RoleUsers), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(RoleUsers), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class Role
    {
        public static IQueryable<Role> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.Role.Where(queryStr, par);
        }
        public static IQueryable<Role> All()
        {
            return LinqUtility.LinqContext.Role;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(Role), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(Role), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class RolePrivileges
    {
        public static IQueryable<RolePrivileges> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.RolePrivileges.Where(queryStr, par);
        }
        public static IQueryable<RolePrivileges> All()
        {
            return LinqUtility.LinqContext.RolePrivileges;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(RolePrivileges), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(RolePrivileges), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class Privileges
    {
        public static IQueryable<Privileges> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.Privileges.Where(queryStr, par);
        }
        public static IQueryable<Privileges> All()
        {
            return LinqUtility.LinqContext.Privileges;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(Privileges), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(Privileges), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class News
    {
        public static IQueryable<News> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.News.Where(queryStr, par);
        }
        public static IQueryable<News> All()
        {
            return LinqUtility.LinqContext.News;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(News), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(News), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class Notice
    {
        public static IQueryable<Notice> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.Notice.Where(queryStr, par);
        }
        public static IQueryable<Notice> All()
        {
            return LinqUtility.LinqContext.Notice;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(Notice), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(Notice), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class TypeInfo
    {
        public static IQueryable<TypeInfo> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.TypeInfo.Where(queryStr, par);
        }
        public static IQueryable<TypeInfo> All()
        {
            return LinqUtility.LinqContext.TypeInfo;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(TypeInfo), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(TypeInfo), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class Project
    {
        public static IQueryable<Project> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.Project.Where(queryStr, par);
        }
        public static IQueryable<Project> All()
        {
            return LinqUtility.LinqContext.Project;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(Project), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(Project), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class Apply
    {
        public static IQueryable<Apply> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.Apply.Where(queryStr, par);
        }
        public static IQueryable<Apply> All()
        {
            return LinqUtility.LinqContext.Apply;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(Apply), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(Apply), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class Evaluate
    {
        public static IQueryable<Evaluate> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.Evaluate.Where(queryStr, par);
        }
        public static IQueryable<Evaluate> All()
        {
            return LinqUtility.LinqContext.Evaluate;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(Evaluate), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(Evaluate), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class WorkRecord
    {
        public static IQueryable<WorkRecord> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.WorkRecord.Where(queryStr, par);
        }
        public static IQueryable<WorkRecord> All()
        {
            return LinqUtility.LinqContext.WorkRecord;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(Apply), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(WorkRecord), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class xy_bmxbm
    {
        public static IQueryable<xy_bmxbm> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.xy_bmxbm.Where(queryStr, par);
        }
        public static IQueryable<xy_bmxbm> All()
        {
            return LinqUtility.LinqContext.xy_bmxbm;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(xy_bmxbm), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(xy_bmxbm), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class xy_xsxx
    {
        public static IQueryable<xy_xsxx> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.xy_xsxx.Where(queryStr, par);
        }
        public static IQueryable<xy_xsxx> All()
        {
            return LinqUtility.LinqContext.xy_xsxx;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(xy_xsxx), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(xy_xsxx), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class xy_jgxx
    {
        public static IQueryable<xy_jgxx> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.xy_jgxx.Where(queryStr, par);
        }
        public static IQueryable<xy_jgxx> All()
        {
            return LinqUtility.LinqContext.xy_jgxx;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(xy_jgxx), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(xy_jgxx), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class xy_bj
    {
        public static IQueryable<xy_bj> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.xy_bj.Where(queryStr, par);
        }
        public static IQueryable<xy_bj> All()
        {
            return LinqUtility.LinqContext.xy_bj;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(xy_bj), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(xy_bj), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class xydm
    {
        public static IQueryable<xydm> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.xydm.Where(queryStr, par);
        }
        public static IQueryable<xydm> All()
        {
            return LinqUtility.LinqContext.xydm;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(xydm), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(xydm), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class xqdm
    {
        public static IQueryable<xqdm> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.xqdm.Where(queryStr, par);
        }
        public static IQueryable<xqdm> All()
        {
            return LinqUtility.LinqContext.xqdm;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(xqdm), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(xqdm), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class DataAssociate
    {
        public static IQueryable<DataAssociate> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.DataAssociate.Where(queryStr, par);
        }
        public static IQueryable<DataAssociate> All()
        {
            return LinqUtility.LinqContext.DataAssociate;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(DataAssociate), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(DataAssociate), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class Score
    {
        public static IQueryable<Score> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.Score.Where(queryStr, par);
        }
        public static IQueryable<Score> All()
        {
            return LinqUtility.LinqContext.Score;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(Score), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(Score), ActionType.Update, entity, where, null, wherePar);
        }
    }

    public partial class ImgList
    {
        public static IQueryable<ImgList> Where(string queryStr, params object[] par)
        {
            return LinqUtility.LinqContext.ImgList.Where(queryStr, par);
        }
        public static IQueryable<ImgList> All()
        {
            return LinqUtility.LinqContext.ImgList;
        }
        /// <summary>
        /// 插入方法
        /// </summary>
        /// <param name="entity">实体</param>
        public static void Insert(object entity)
        {
            LinqUtility.UpdateContextData(null, ActionType.Insert, entity, null, null, null);
        }
        /// <summary>
        /// 删除方法
        /// </summary>
        /// <param name="tableType">表类型</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Delete(string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(ImgList), ActionType.Delete, null, where, null, wherePar);
        }
        /// <summary>
        /// 更新方法
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="where">查询表达式</param>
        /// <param name="wherePar">参数</param>
        public static void Update(object entity, string where, params object[] wherePar)
        {
            LinqUtility.UpdateContextData(typeof(ImgList), ActionType.Update, entity, where, null, wherePar);
        }
    }
}
